1
2
3
4
další
Najděte index prvku pole, který chcete odebrat, pomocí indexOf a poté tento index odstraňte spojením.
Metoda splice () změní obsah pole odstraněním
existující prvky a / nebo přidávání nových prvků.
const pole = [2, 5, 9];
console.log (pole);
const index = array.indexOf (5);
if (index> -1) {
array.splice (index, 1);
}
// pole = [2, 9]
console.log (pole);
Druhým parametrem sestřihu je počet prvků, které mají být odstraněny. Všimněte si, že spoj upraví pole na místě a vrátí nové pole obsahující prvky, které byly odstraněny.
Z důvodu úplnosti jsou zde funkce. První funkce odstraní pouze jeden výskyt (tj. Odebrání první shody 5 z [2,5,9,1,5,8,5]), zatímco druhá funkce odstraní všechny výskyty:
funkce removeItemOnce (arr, hodnota) {
var index = arr.indexOf (hodnota);
if (index> -1) {
arr.splice (index, 1);
}
návrat arr;
}
funkce removeItemAll (arr, hodnota) {
var i = 0;
while (i = 0; i--) {
if (pole [i] === číslo) {
array.splice (i, 1);
}
}
Pokud chcete pouze vytvořit prvek v indexu, už neexistuji, ale nechcete, aby se indexy ostatních prvků změnily:
vymazat pole [i];
|
Upraveno v říjnu 2016
Udělejte to jednoduché, intuitivní a explicitní (holicí strojek Occam)
Udělejte to neměnné (původní pole zůstane nezměněno)
Udělejte to se standardními funkcemi JavaScript, pokud je váš prohlížeč nepodporuje - použijte polyfill
V tomto příkladu kódu používám funkci "array.filter (...)" k odstranění nežádoucích položek z pole. Tato funkce nezmění původní pole a vytvoří nové. Pokud váš prohlížeč tuto funkci nepodporuje (např. Internet Explorer před verzí 9 nebo Firefox před verzí 1.5), zvažte použití filtrační polyfill od Mozilly.
Odebrání položky (kód ECMA-262 Edition 5 aka oldstyle JavaScript)
hodnota var = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (funkce (položka) {
vrátit položku! == hodnota
})
console.log (arr)
// [1, 2, 4, 5]
Odebírání položky (kód ECMAScript 6)
nechť hodnota = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (položka => položka! == hodnota)
console.log (arr)
// [1, 2, 4, 5]
DŮLEŽITÉ ECMAScript 6 "() => {}" syntaxe funkce šipky není v prohlížeči Internet Explorer vůbec podporována, Chrome před 45 verzí, Firefox před 22 verzí a Safari před 10 verzí. Chcete-li použít syntaxi ECMAScript 6 ve starých prohlížečích, můžete použít BabelJS.
Odebrání více položek (kód ECMAScript 7)
Další výhodou této metody je, že můžete odebrat více položek
let forDeletion = [2, 3, 5]
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Přečtěte si níže o podpoře array.includes (...) !!!
console.log (arr)
// [1, 4]
DŮLEŽITÉ funkce „array.includes (...)“ není v Internet Exploreru vůbec podporována, Chrome před 47 verzí, Firefox před 43 verzí, Safari před 9 verzí a Edge před 14 verzí, takže zde je polyfill od Mozilly.
Odebrání více položek (možná v budoucnu)
Pokud bude někdy přijat návrh „This-Binding Syntax“, budete to moci udělat:
// array-lib.js
funkce exportu remove (... forDeletion) {
vrátit this.filter (item =>! forDeletion.includes (item))
}
// main.js
importovat {odebrat} z './array-lib.js'
let arr = [1, 2, 3, 4, 5, 3]
// :: This-Binding Syntax Proposal
// použití funkce „remove“ jako „virtuální metody“
// bez rozšíření Array.prototype
arr = arr :: remove (2, 3, 5)
console.log (arr)
// [1, 4]
Vyzkoušejte sami v BabelJS :)
Odkaz
Pole. Prototyp. Zahrnuje
Funkční složení
|
Záleží na tom, zda si chcete ponechat prázdné místo, nebo ne.
Pokud chcete prázdný slot:
pole [index] = nedefinováno;
Pokud nechcete prázdný slot:
// Zachování originálu:
// oldArray = [... pole];
// Tím se upraví pole.
array.splice (index, 1);
A pokud potřebujete hodnotu této položky, můžete jednoduše uložit prvek vráceného pole:
var hodnota = array.splice (index, 1) [0];
Pokud chcete odebrat na obou koncích pole, můžete použít array.pop () pro poslední nebo array.shift () pro první (oba vrátí také hodnotu položky).
Pokud neznáte index položky, můžete ji získat array.indexOf (item) k získání (v if () k získání jedné položky nebo za chvíli () k získání všech). array.indexOf (item) vrací buď index, nebo -1, pokud nebyl nalezen.
|
Přítel měl problémy v aplikaci Internet Explorer 8 a ukázal mi, co udělal. Řekl jsem mu, že je to špatně, a on mi řekl, že dostal odpověďtady. Aktuální hlavní odpověď nebude fungovat ve všech prohlížečích (například Internet Explorer 8) a odstraní pouze první výskyt položky.
Odeberte VŠECHNY instance z pole
funkce array_remove_index_by_value (arr, item)
{
pro (var i = délka příletu; i--;)
{
if (arr [i] === položka) {arr.splice (i, 1);}
}
}
Prochází polem vzad (protože indexy a délka se budou měnit, jakmile budou položky odstraněny) a odstraní položku, pokud je nalezena. Funguje ve všech prohlížečích.
|
Existují dva hlavní přístupy:
splice (): anArray.splice (index, 1);
delete: odstranit anArray [index];
Buďte opatrní, když pro pole používáte odstranit. Je to dobré pro mazání atributů objektů, ale ne tak dobré pro pole. Je lepší použít spoj pro pole.
Mějte na paměti, že když použijete odstranit pro pole, můžete získat špatné výsledky pro anArray.length. Jinými slovy, odstranění by odstranilo prvek, ale neaktualizovalo by to hodnotu vlastnosti délky.
Můžete také očekávat, že po použití mazání budete mít v indexových číslech díry, např. můžete skončit s indexy 1, 3, 4, 8, 9 a 11 a délkou, jaká byla před použitím mazání. V takovém případě by všechny indexované smyčky selhaly, protože indexy již nejsou sekvenční.
Pokud jste z nějakého důvodu nuceni používat odstranění, měli byste použít pro každou smyčku, když potřebujete procházet pole. Ve skutečnosti se vždy vyhněte použití indexovaných smyček, pokud je to možné. Tímto způsobem by byl kód robustnější a méně náchylný k problémům s indexy.
|
Array.prototype.remove_by_value = funkce (val) {
for (var i = 0; i row.id === 5);
var odstraněn = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definice
var helper = {
// Odebrání a vrácení prvního výskytu
removeOne: funkce (pole, predikát) {
for (var i = 0; i [2, 3, 4]
|
Můžete použít ES6. Chcete-li například v tomto případě odstranit hodnotu „3“:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((value) => value! = '3');
console.log (newArray);
Výstup :
["1", "2", "4", "5", "6"]
|
Pokud chcete nové pole s odstraněnými odstraněnými pozicemi, můžete vždy odstranit konkrétní prvek a vyfiltrovat pole. Možná bude potřeba rozšíření objektu pole pro prohlížeče, které neimplementují metodu filtrování, ale z dlouhodobého hlediska je to jednodušší, protože vše, co děláte, je toto:
var my_array = [1, 2, 3, 4, 5, 6];
odstranit my_array [4];
console.log (my_array.filter (function (a) {return typeof a! == 'undefined';})));
Mělo by se zobrazit [1, 2, 3, 4, 6].
|
Tady je několik způsobů, jak odstranit položku z pole pomocí JavaScriptu.
Všechny popsané metody nemutují původní pole a místo toho vytvoří nové.
Pokud znáte rejstřík položky
Předpokládejme, že máte pole a chcete odebrat položku na pozici i.
Jednou z metod je použití slice ():
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filtrované položky = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filtrované položky)
slice () vytvoří nové pole s indexy, které obdrží. Jednoduše vytvoříme nové pole od začátku do indexu, který chceme odstranit, a zřetězíme další pole z první pozice následující po té, kterou jsme odstranili, na konec pole.
Pokud znáte hodnotu
V tomto případě je dobrou volbou použít filter (), který nabízí více deklarativní přístup:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
constfiltrItems = items.filter (item => item! == valueToRemove)
console.log (filtrované položky)
Toto využívá funkce šipek ES6. K podpoře starších prohlížečů můžete použít tradiční funkce:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
constfiltrItems = items.filter (funkce (položka) {
vrátit položku! == valueToRemove
})
console.log (filtrované položky)
nebo můžete použít Babel a přenést kód ES6 zpět na ES5, aby byl lépe stravitelný pro staré prohlížeče, a přesto do svého kódu napište moderní JavaScript.
Odebírání více položek
Co když chcete místo jedné položky odebrat mnoho položek?
Najdeme nejjednodušší řešení.
Podle indexu
Stačí vytvořit funkci a odebrat položky v sérii:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
letfiltrItems = removeItem (položky, 3)
filtrované položky = removeItem (filtrované položky, 5)
//["abeceda"]
console.log (filtrované položky)
Podle hodnoty
Můžete hledat zahrnutí do funkce zpětného volání:
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
constfiltrItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filtrované položky)
Vyvarujte se mutování původního pole
splice () (nezaměňovat s slice ()) mutuje původní pole a je třeba se mu vyhnout.
(původně zveřejněno na mém webu https://flaviocopes.com/how-to-remove-item-from-array/)
|
Podívejte se na tento kód. Funguje ve všech hlavních prohlížečích.
remove_item = funkce (arr, hodnota) {
var b = '';
pro (b in arr) {
if (arr [b] === hodnota) {
arr.splice (b, 1);
přestávka;
}
}
návrat arr;
};
Zavolejte tuto funkci
remove_item (pole, hodnota);
|
ES6 a bez mutace: (říjen 2016)
const removeByIndex = (seznam, index) =>
[
... list.slice (0, index),
... list.slice (index + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (výstup)
|
Můžete použít lodash _.pull (mutovat pole), _.pullAt (mutovat pole) nebo _.without (nemění pole),
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (pole2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Odebrání konkrétního prvku / řetězce z pole lze provést v jedné linii:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
kde:
theArray: pole, ze kterého chcete odstranit něco konkrétního
stringToRemoveFromArray: řetězec, který chcete odebrat, a 1 je množství prvků, které chcete odebrat.
POZNÁMKA: Pokud řetězec „stringToRemoveFromArray“ není umístěn v poli, bude odstraněn poslední prvek pole.
Vždy je dobré zkontrolovat, zda prvek ve vašem poli nejprve existuje, než jej odstraníte.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Pokud máte přístup k novějším verzím Ecmascript na počítačích vašeho klienta (UPOZORNĚNÍ, nemusí fungovat na starších stanicích):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((value) => value! = '3');
Kde '3' je hodnota, kterou chcete z pole odstranit.
Pole by se poté stalo: ['1', '2', '4', '5', '6']
|
Dobře, například máte pole níže:
var num = [1, 2, 3, 4, 5];
A chceme odstranit číslo 4. Můžete jednoduše použít následující kód:
num.splice (num.indexOf (4), 1); // num bude [1, 2, 3, 5];
Pokud znovu používáte tuto funkci, napíšete opakovaně použitelnou funkci, která bude připojena k funkci nativního pole, jak je uvedeno níže:
Array.prototype.remove = Array.prototype.remove || funkce (x) {
const i = this.indexOf (x);
if (i === - 1)
vrátit se;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Ale co kdybyste místo toho měli níže uvedené pole s několika [5] s v poli?
var num = [5, 6, 5, 4, 5, 1, 5];
Potřebujeme smyčku, abychom je všechny zkontrolovali, ale jednodušší a efektivnější způsob je použití vestavěných funkcí JavaScriptu, takže místo toho napíšeme funkci, která používá filtr jako níže:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // návrat [1, 2, 3, 4, 6]
K dispozici jsou také knihovny třetích stran, jako je Lodash nebo Underscore. Další informace najdete v lodash _.pull, _.pullAt nebo _.without.
|
Výkon
Dnes (9. 12. 2019) provádím u vybraných řešení testy výkonu v systému macOS v10.13.6 (High Sierra). Zobrazuji delete (A), ale nepoužívám to ve srovnání s jinými metodami, protože v poli zůstalo prázdné místo.
Závěry
nejrychlejším řešením je array.splice (C) (s výjimkou Safari pro malá pole, kde má podruhé)
pro velká pole je array.slice + splice (H) nejrychlejší neměnné řešení pro Firefox a Safari; Array.from (B) je v Chromu nejrychlejší
měnitelná řešení jsou obvykle 1,5x-6x rychlejší než neměnná
u malých stolů na Safari je překvapivě proměnlivé řešení (C) pomalejší než neměnné řešení (G)
Detaily
V testech odstraním prostřední prvek z pole různými způsoby. Řešení A, C jsou na místě. Řešení B, D, E, F, G, H jsou neměnná.
Výsledky pro pole s 10 prvky
V Chrome je array.splice (C) nejrychlejším řešením na místě. Array.filter (D) je nejrychlejší neměnné řešení. Nejpomalejší je array.slice (F). Zde můžete provést test na svém stroji.
Výsledky pro pole s 1 000 000 prvky
V Chrome je array.splice (C) nejrychlejším řešením na místě (mazání (C) je podobné rychlé - ale v poli zůstal prázdný slot (takže neprovádí úplné odebrání)). Pole.slice-splice (H) je nejrychlejší neměnné řešení. Nejpomalejší je array.filter (D a E). Zde můžete provést test na svém stroji.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
funkce A (pole) {
var index = array.indexOf (5);
odstranit pole [index];
log ('A', pole);
}
funkce B (pole) {
var index = array.indexOf (5);
var arr = Array.from (pole);
arr.splice (index, 1)
log ('B', arr);
}
funkce C (pole) {
var index = array.indexOf (5);
array.splice (index, 1);
log ('C', pole);
}
funkce D (pole) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}
funkce E (pole) {
var index = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}
funkce F (pole) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
log ('F', arr);
}
funkce G (pole) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}
funkce H (pole) {
var index = array.indexOf (5);
var arr = pole.slice (0);
arr.splice (index, 1);
log ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
F ([... a]);
G ([... a]);
H ([... a]);
Tento úryvek představuje pouze kód použitý v testech výkonu - neprovádí testy sám.
Srovnání pro prohlížeče: Chrome v78.0.0, Safari v13.0.4 a Firefox v71.0.0
|
Jsem v JavaScriptu docela nový a potřeboval jsem tuto funkci. Pouze jsem napsal toto:
funkce removeFromArray (pole, položka, index) {
while ((index = array.indexOf (item))> -1) {
array.splice (index, 1);
}
}
Pak, když to chci použít:
// Nastavení některých fiktivních dat
var dummyObj = {name: "mňau"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Odebrat fiktivní data
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Výstup - podle očekávání.
["item1", "item1"]
Možná máte jiné potřeby než já, takže je můžete snadno upravitaby jim vyhovovaly. Doufám, že to někomu pomůže.
|
Pokud máte v poli složité objekty, můžete použít filtry?
V situacích, kdy není použití $ .inArray nebo array.splice tak snadné. Zvláště pokud jsou objekty v poli možná mělké.
Např. pokud máte objekt s polem Id a chcete objekt odstranit z pole:
this.array = this.array.filter (funkce (prvek, i) {
návrat element.id! == idToRemove;
});
|
Chci odpovědět na základě ECMAScript 6. Předpokládejme, že máte pole jako níže:
let arr = [1,2,3,4];
Pokud chcete mazat na speciálním indexu, jako je 2, napište následující kód:
arr.splice (2, 1); // => arr se stal [1,2,4]
Pokud ale chcete smazat speciální položku jako 3 a neznáte její index, postupujte takto:
arr = arr.filter (e => e! == 3); // => arr se stal [1,2,4]
Tip: prosím, použijte funkci šipky pro zpětné volání filtru, pokud nezískáte prázdné pole.
|
Aktualizace: Tato metoda se doporučuje pouze v případě, že nemůžete použít ECMAScript 2015 (dříve známý jako ES6). Pokud ji můžete použít, další odpovědi zde poskytují mnohem přehlednější implementace.
Tento seznam zde vyřeší váš problém a také odstraní všechny výskyty argumentu namísto pouze 1 (nebo zadané hodnoty).
Array.prototype.destroy = funkce (obj) {
// Vrací null, pokud nebyly nalezeny a odstraněny žádné objekty
var zničeno = null;
for (var i = 0; i 3
x.destroy (false); // => false
X; // => [1, 2, true, undefined]
x.destroy (true); // => pravda
x. zničit (nedefinováno); // => undefined
X; // => [1, 2]
x. zničit (3); // => null
X; // => [1, 2]
|
Aktualizace ES10
Tento příspěvek shrnuje běžné přístupy k odstraňování prvků z pole od ECMAScript 2019 (ES10).
1. Obecné případy
1.1. Odebrání prvku Array podle hodnoty pomocí .splice ()
| Na místě: Ano |
| Odstraní duplikáty: Ano (smyčka), Ne (indexOf) |
| Podle hodnoty / indexu: Podle indexu
Pokud znáte hodnotu, kterou chcete z pole odebrat, můžete použít metodu spojování. Nejprve musíte identifikovat index cílové položky. Poté použijete index jako počáteční prvek a odeberete pouze jeden prvek.
// Se smyčkou „pro“
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
pro (nechť i = 0; i [1, 2, 3, 4, 6, 7, 8, 9, 0]
// S metodou .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Odebrání prvku Array pomocí metody .filter ()
| Na místě: Ne |
| Odstraní duplikáty: Ano |
| Podle hodnoty / indexu: Podle hodnoty |
Specifický prvek lze odfiltrovat z pole poskytnutím funkce filtrování. Taková funkce je poté volána pro každý prvek v poli.
konstantní hodnota = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (položka => položka! == hodnota)
console.log (arr)
// [1, 2, 4, 5]
1.3. Odebrání prvku Array rozšířením Array.prototype
| Na místě: Ano / Ne (záleží na implementaci) |
| Odstraní duplikáty: Ano / Ne (záleží na implementaci) |
| Podle hodnoty / indexu: Podle indexu / Podle hodnoty (závisí na implementaci) |
Prototyp pole lze rozšířit dalšími metodami. Tyto metody pak budou k dispozici pro použití na vytvořených polích.
Poznámka: Někteří považují rozšíření prototypů objektů ze standardní knihovny JavaScriptu (jako je Array) za antipattern.
// Na místě, odstraní vše podle implementace hodnoty
Array.prototype.remove = funkce (položka) {
for (let i = 0; i = ES10)
| Na místě: Ne |
| Odstraní duplikáty: Ano |
| Podle hodnoty / indexu: Podle hodnoty |
ES10 představil Object.fromEntries, což může býtslouží k vytvoření požadovaného pole z libovolného objektu podobného pole a filtrování nežádoucích prvků během procesu.
const objekt = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values (Object.fromEntries (
Object.entries (objekt)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Zvláštní případy
2.1 Odstranění prvku, pokud je na konci pole
2.1.1. Změna délky pole
| Na místě: Ano |
| Odstraní duplikáty: Ne |
| Podle hodnoty / indexu: N / A |
Prvky pole JavaScript lze odebrat z konce pole nastavením vlastnosti length na hodnotu menší než aktuální hodnota. Jakýkoli prvek, jehož index je větší nebo roven nové délce, bude odstraněn.
const arr = [1, 2, 3, 4, 5, 6];
dorazová délka = 5; // Nastavit délku pro odebrání prvku
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Použití metody .pop ()
| Na místě: Ano |
| Odstraní duplikáty: Ne |
| Podle hodnoty / indexu: N / A |
Metoda pop odebere poslední prvek pole, vrátí tento prvek a aktualizuje vlastnost délky. Metoda pop upravuje pole, na které je vyvolána. To znamená, že na rozdíl od použití mazání je poslední prvek zcela odstraněn a délka pole snížena.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // vrátí 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Odstranění prvku, pokud je na začátku pole
| Na místě: Ano |
| Odstraní duplikáty: Ne |
| Podle hodnoty / indexu: N / A |
Metoda .shift () funguje podobně jako metoda pop, kromě toho, že odstraní první prvek pole JavaScript namísto posledního. Když je prvek odstraněn, zbývající prvky jsou posunuty dolů.
const arr = [1, 2, 3, 4];
arr.shift (); // vrátí 1
console.log (arr); // [2, 3, 4]
2.3. Odebrání prvku, pokud je to jediný prvek v poli
| Na místě: Ano |
| Odstraní duplikáty: N / A |
| Podle hodnoty / indexu: N / A |
Nejrychlejší technikou je nastavit proměnnou pole na prázdné pole.
let arr = [1];
arr = []; // prázdné pole
Alternativně lze použít techniku z 2.1.1 nastavením délky na 0.
|
Nikdy byste neměli mutovat své pole. Protože je to proti vzorci funkčního programování. Můžete vytvořit nové pole bez odkazu na pole, u kterého chcete změnit data, pomocí filtru metody ECMAScript 6;
var myArray = [1, 2, 3, 4, 5, 6];
Předpokládejme, že chcete odstranit 5 z pole, můžete to jednoduše udělat takto:
myArray = myArray.filter (hodnota => hodnota! == 5);
Tím získáte nové pole bez hodnoty, kterou jste chtěli odstranit. Výsledek tedy bude:
[1, 2, 3, 4, 6]; // 5 bylo odstraněno z tohoto pole
Pro další pochopení si můžete přečíst dokumentaci MDN na Array.filter.
|
Modernější přístup ECMAScript 2015 (dříve známý jako Harmony nebo ES 6). Dané:
const položky = [1, 2, 3, 4];
index konst = 2;
Pak:
items.filter ((x, i) => i! == index);
Poddajný:
[1, 2, 4]
K zajištění dobré podpory ve všech prohlížečích můžete použít Babel a službu polyfill.
|
Pokud existuje více instancí elementu, můžete udělat zpětnou smyčku, abyste se ujistili, že indexy neposekujete.
var myElement = "čokoláda";
var myArray = ['čokoláda', 'poptart', 'poptart', 'poptart', 'čokoláda', 'poptart', 'poptart', 'čokoláda'];
/ * Důležitý kód * /
for (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Živé demo
|
V poli máte 1 až 9 a chcete odebrat 5. Použijte následující kód:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
návrat m! == 5;
});
console.log ("nové pole, 5 odstraněno", newNumberArray);
Pokud chcete více hodnot. Příklad: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
návrat (m! == 1) && (m! == 7) && (m! == 8);
});
console.log („nové pole, 1,7 a 8 odstraněno“, newNumberArray);
Pokud chcete z pole odebrat hodnotu pole. Příklad: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
návrat! removebleArray.includes (m);
});
console.log ("new Array, [3,4,5] odstraněn", newNumberArray);
Zahrnuje podporovaný prohlížeč je odkaz.
|
1
2
3
4
další
Vysoce aktivní otázka. Získejte 10 reputace, abyste mohli odpovědět na tuto otázku. Požadavek na reputaci pomáhá chránit tuto otázku před spamem a neodpovědností.
Toto není odpověď, kterou hledáte? Projděte si další otázky označené poli javascript nebo položte vlastní otázku.